ವೇಗವಾದ, ಹೆಚ್ಚು ಸಮರ್ಥ ಕೋಡ್ ಅನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿ. ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಮತ್ತು ಗ್ರೀಡಿ vs. ಲೇಜಿ ಮ್ಯಾಚಿಂಗ್‌ನಿಂದ ಹಿಡಿದು ಸುಧಾರಿತ ಎಂಜಿನ್-ನಿರ್ದಿಷ್ಟ ಟ್ಯೂನಿಂಗ್‌ವರೆಗಿನ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಾಗಿ ಅಗತ್ಯ ತಂತ್ರಗಳನ್ನು ಕಲಿಯಿರಿ.
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಆಪ್ಟಿಮೈಸೇಶನ್: ರೆಜೆಕ್ಸ್ ಕಾರ್ಯಕ್ಷಮತೆ ಟ್ಯೂನಿಂಗ್‌ನ ಆಳವಾದ ವಿಶ್ಲೇಷಣೆ
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು, ಅಥವಾ ರೆಜೆಕ್ಸ್, ಆಧುನಿಕ ಪ್ರೋಗ್ರಾಮರ್‌ನ ಟೂಲ್‌ಕಿಟ್‌ನಲ್ಲಿ ಒಂದು ಅನಿವಾರ್ಯ ಸಾಧನವಾಗಿದೆ. ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದರಿಂದ ಮತ್ತು ಲಾಗ್ ಫೈಲ್‌ಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದರಿಂದ ಹಿಡಿದು ಅತ್ಯಾಧುನಿಕ ಸರ್ಚ್-ಅಂಡ್-ರಿಪ್ಲೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಡೇಟಾ ಹೊರತೆಗೆಯುವವರೆಗೆ, ಅವುಗಳ ಶಕ್ತಿ ಮತ್ತು ಬಹುಮುಖತೆ ನಿರಾಕರಿಸಲಾಗದು. ಆದಾಗ್ಯೂ, ಈ ಶಕ್ತಿಯು ಒಂದು ಗುಪ್ತ ವೆಚ್ಚದೊಂದಿಗೆ ಬರುತ್ತದೆ. ಕಳಪೆಯಾಗಿ ಬರೆಯಲಾದ ರೆಜೆಕ್ಸ್ ಒಂದು ಸದ್ದಿಲ್ಲದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಕುಗ್ಗಿಸುವ ಅಂಶವಾಗಬಹುದು, ಗಮನಾರ್ಹ ಲೇಟೆನ್ಸಿಯನ್ನು ಪರಿಚಯಿಸಬಹುದು, CPU ಸ್ಪೈಕ್‌ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು ಮತ್ತು ಕೆಟ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ಥಗಿತಗೊಳಿಸಬಹುದು. ಇಲ್ಲಿಯೇ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಆಪ್ಟಿಮೈಸೇಶನ್ ಕೇವಲ 'ಹೊಂದಿದ್ದರೆ-ಒಳ್ಳೆಯದು' ಕೌಶಲ್ಯವಲ್ಲ, ಬದಲಿಗೆ ದೃಢವಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಸಾಫ್ಟ್‌ವೇರ್ ನಿರ್ಮಿಸಲು ನಿರ್ಣಾಯಕವಾಗುತ್ತದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ನಿಮ್ಮನ್ನು ರೆಜೆಕ್ಸ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಜಗತ್ತಿನಲ್ಲಿ ಆಳವಾಗಿ ಕೊಂಡೊಯ್ಯುತ್ತದೆ. ತೋರಿಕೆಯಲ್ಲಿ ಸರಳವಾದ ಪ್ಯಾಟರ್ನ್ ಏಕೆ ವಿನಾಶಕಾರಿಯಾಗಿ ನಿಧಾನವಾಗಬಹುದು ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ, ರೆಜೆಕ್ಸ್ ಎಂಜಿನ್‌ಗಳ ಆಂತರಿಕ ಕಾರ್ಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಸರಿಯಾದದ್ದು ಮಾತ್ರವಲ್ಲದೆ, ಅತ್ಯಂತ ವೇಗವಾಗಿರುವ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಬರೆಯಲು ನಿಮಗೆ ಶಕ್ತಿಯುತವಾದ ತತ್ವಗಳು ಮತ್ತು ತಂತ್ರಗಳ ಗುಂಪನ್ನು ಸಜ್ಜುಗೊಳಿಸುತ್ತೇವೆ.
'ಏಕೆ' ಎಂದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು: ಒಂದು ಕೆಟ್ಟ ರೆಜೆಕ್ಸ್‌ನ ಪರಿಣಾಮ
ನಾವು ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು, ನಾವು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಸಮಸ್ಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಅತ್ಯಂತ ತೀವ್ರವಾದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಯನ್ನು ಕ್ಯಾಟಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ (Catastrophic Backtracking) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಇದು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಡಿನೈಯಲ್ ಆಫ್ ಸರ್ವೀಸ್ (ReDoS) ದುರ್ಬಲತೆಗೆ ಕಾರಣವಾಗಬಹುದು.
ಕ್ಯಾಟಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಎಂದರೇನು?
ಒಂದು ರೆಜೆಕ್ಸ್ ಎಂಜಿನ್ ಒಂದು ಹೊಂದಾಣಿಕೆಯನ್ನು ಹುಡುಕಲು (ಅಥವಾ ಯಾವುದೇ ಹೊಂದಾಣಿಕೆ ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ನಿರ್ಧರಿಸಲು) ಅಸಾಧಾರಣವಾಗಿ ದೀರ್ಘ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಂಡಾಗ ಕ್ಯಾಟಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಸಂಭವಿಸುತ್ತದೆ. ಇದು ನಿರ್ದಿಷ್ಟ ರೀತಿಯ ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ವಿರುದ್ಧವಾಗಿ ನಿರ್ದಿಷ್ಟ ರೀತಿಯ ಪ್ಯಾಟರ್ನ್‌ಗಳೊಂದಿಗೆ ಸಂಭವಿಸುತ್ತದೆ. ಎಂಜಿನ್, ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಪೂರೈಸಲು ಪ್ರತಿಯೊಂದು ಸಂಭಾವ್ಯ ಮಾರ್ಗವನ್ನು ಪ್ರಯತ್ನಿಸುತ್ತಾ, ಕ್ರಮಪಲ್ಲಟನೆಗಳ ಒಂದು ತಲೆತಿರುಗುವ ಜಟಿಲದಲ್ಲಿ ಸಿಕ್ಕಿಹಾಕಿಕೊಳ್ಳುತ್ತದೆ. ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದದೊಂದಿಗೆ ಹಂತಗಳ ಸಂಖ್ಯೆಯು ಘಾತೀಯವಾಗಿ ಬೆಳೆಯಬಹುದು, ಇದು ಅಪ್ಲಿಕೇಶನ್ ಫ್ರೀಜ್ ಆದಂತೆ ತೋರುತ್ತದೆ.
ಈ ದುರ್ಬಲ ರೆಜೆಕ್ಸ್‌ನ ಒಂದು ಕ್ಲಾಸಿಕ್ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ: ^(a+)+$
ಈ ಪ್ಯಾಟರ್ನ್ ಸಾಕಷ್ಟು ಸರಳವಾಗಿ ಕಾಣುತ್ತದೆ: ಇದು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ 'a' ಗಳಿಂದ ಕೂಡಿದ ಸ್ಟ್ರಿಂಗ್‌ಗಾಗಿ ಹುಡುಕುತ್ತದೆ. ಇದು "a", "aa", ಮತ್ತು "aaaaa" ನಂತಹ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ನಾವು ಅದನ್ನು ಬಹುತೇಕ ಹೊಂದಿಕೆಯಾಗುವ ಆದರೆ ಅಂತಿಮವಾಗಿ ವಿಫಲವಾಗುವ "aaaaaaaaaaaaaaaaaaaaaaaaaaab" ನಂತಹ ಸ್ಟ್ರಿಂಗ್‌ನ ವಿರುದ್ಧ ಪರೀಕ್ಷಿಸಿದಾಗ ಸಮಸ್ಯೆ ಉದ್ಭವಿಸುತ್ತದೆ.
ಇದು ಏಕೆ ಅಷ್ಟು ನಿಧಾನವಾಗಿದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:
- ಹೊರಗಿನ
(...)+ಮತ್ತು ಒಳಗಿನa+ಎರಡೂ ಗ್ರೀಡಿ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳಾಗಿವೆ. - ಒಳಗಿನ
a+ಮೊದಲು ಎಲ್ಲಾ 27 'a' ಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ. - ಹೊರಗಿನ
(...)+ಈ ಒಂದೇ ಹೊಂದಾಣಿಕೆಯಿಂದ ತೃಪ್ತವಾಗಿದೆ. - ನಂತರ ಎಂಜಿನ್ ಎಂಡ್-ಆಫ್-ಸ್ಟ್ರಿಂಗ್ ಆಂಕರ್
$ಅನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. 'b' ಇರುವುದರಿಂದ ಅದು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. - ಈಗ, ಎಂಜಿನ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕು. ಹೊರಗಿನ ಗುಂಪು ಒಂದು ಅಕ್ಷರವನ್ನು ಬಿಟ್ಟುಕೊಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಒಳಗಿನ
a+ಈಗ 26 'a' ಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ, ಮತ್ತು ಹೊರಗಿನ ಗುಂಪಿನ ಎರಡನೇ ಪುನರಾವರ್ತನೆಯು ಕೊನೆಯ 'a' ಅನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಇದು ಕೂಡ 'b' ನಲ್ಲಿ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. - ಎಂಜಿನ್ ಈಗ ಒಳಗಿನ
a+ಮತ್ತು ಹೊರಗಿನ(...)+ನಡುವೆ 'a' ಗಳ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ವಿಭಜಿಸಲು ಪ್ರತಿಯೊಂದು ಸಂಭಾವ್ಯ ಮಾರ್ಗವನ್ನು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. N 'a' ಗಳ ಸ್ಟ್ರಿಂಗ್‌ಗೆ, ಅದನ್ನು ವಿಭಜಿಸಲು 2N-1 ಮಾರ್ಗಗಳಿವೆ. ಸಂಕೀರ್ಣತೆಯು ಘಾತೀಯವಾಗಿದೆ, ಮತ್ತು ಪ್ರೊಸೆಸಿಂಗ್ ಸಮಯವು ಗಗನಕ್ಕೇರುತ್ತದೆ.
ಈ ಒಂದೇ, ತೋರಿಕೆಯಲ್ಲಿ ನಿರುಪದ್ರವಿ ರೆಜೆಕ್ಸ್ ಒಂದು CPU ಕೋರ್ ಅನ್ನು ಸೆಕೆಂಡುಗಳು, ನಿಮಿಷಗಳು ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಕಾಲ ಲಾಕ್ ಮಾಡಬಹುದು, ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಇತರ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಅಥವಾ ಬಳಕೆದಾರರಿಗೆ ಸೇವೆಯನ್ನು ನಿರಾಕರಿಸುತ್ತದೆ.
ವಿಷಯದ ತಿರುಳು: ರೆಜೆಕ್ಸ್ ಎಂಜಿನ್
ರೆಜೆಕ್ಸ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು, ಎಂಜಿನ್ ನಿಮ್ಮ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. ಎರಡು ಪ್ರಮುಖ ರೀತಿಯ ರೆಜೆಕ್ಸ್ ಎಂಜಿನ್‌ಗಳಿವೆ, ಮತ್ತು ಅವುಗಳ ಆಂತರಿಕ ಕಾರ್ಯಗಳು ಕಾರ್ಯಕ್ಷಮತೆಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ನಿರ್ಧರಿಸುತ್ತವೆ.
DFA (ಡಿಟರ್ಮಿನಿಸ್ಟಿಕ್ ಫೈನೈಟ್ ಆಟೋಮ್ಯಾಟನ್) ಎಂಜಿನ್‌ಗಳು
DFA ಎಂಜಿನ್‌ಗಳು ರೆಜೆಕ್ಸ್ ಪ್ರಪಂಚದ ವೇಗದ ದೈತ್ಯರು. ಅವು ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ, ಅಕ್ಷರದಿಂದ ಅಕ್ಷರಕ್ಕೆ ಒಂದೇ ಪಾಸ್‌ನಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತವೆ. ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಹಂತದಲ್ಲಿ, ಪ್ರಸ್ತುತ ಅಕ್ಷರದ ಆಧಾರದ ಮೇಲೆ ಮುಂದಿನ ಸ್ಥಿತಿ ಏನೆಂದು DFA ಎಂಜಿನ್‌ಗೆ ನಿಖರವಾಗಿ ತಿಳಿದಿರುತ್ತದೆ. ಇದರರ್ಥ ಅದು ಎಂದಿಗೂ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕಾಗಿಲ್ಲ. ಪ್ರೊಸೆಸಿಂಗ್ ಸಮಯವು ರೇಖೀಯವಾಗಿದೆ ಮತ್ತು ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್‌ನ ಉದ್ದಕ್ಕೆ ನೇರವಾಗಿ ಅನುಪಾತದಲ್ಲಿರುತ್ತದೆ. grep ಮತ್ತು awk ನಂತಹ ಸಾಂಪ್ರದಾಯಿಕ ಯುನಿಕ್ಸ್ ಪರಿಕರಗಳು DFA-ಆಧಾರಿತ ಎಂಜಿನ್‌ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳಾಗಿವೆ.
ಅನುಕೂಲಗಳು: ಅತ್ಯಂತ ವೇಗದ ಮತ್ತು ನಿರೀಕ್ಷಿತ ಕಾರ್ಯಕ್ಷಮತೆ. ಕ್ಯಾಟಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್‌ನಿಂದ ನಿರೋಧಕ.
ಅನಾನುಕೂಲಗಳು: ಸೀಮಿತ ವೈಶಿಷ್ಟ್ಯಗಳ ಸೆಟ್. ಅವು ಬ್ಯಾಕ್‌ರೆಫರೆನ್ಸ್‌ಗಳು, ಲುಕ್‌ಅರೌಂಡ್‌ಗಳು, ಅಥವಾ ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗುಂಪುಗಳಂತಹ ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ, ಇವು ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಅವಲಂಬಿಸಿವೆ.
NFA (ನಾನ್‌ಡಿಟರ್ಮಿನಿಸ್ಟಿಕ್ ಫೈನೈಟ್ ಆಟೋಮ್ಯಾಟನ್) ಎಂಜಿನ್‌ಗಳು
NFA ಎಂಜಿನ್‌ಗಳು ಪೈಥಾನ್, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಜಾವಾ, C# (.NET), ರೂಬಿ, PHP, ಮತ್ತು ಪರ್ಲ್‌ನಂತಹ ಆಧುನಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುವ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ಪ್ರಕಾರವಾಗಿದೆ. ಅವು "ಪ್ಯಾಟರ್ನ್-ಚಾಲಿತ" ಆಗಿರುತ್ತವೆ, ಅಂದರೆ ಎಂಜಿನ್ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಅನುಸರಿಸುತ್ತದೆ, ಸ್ಟ್ರಿಂಗ್‌ನ ಮೂಲಕ ಮುಂದುವರಿಯುತ್ತದೆ. ಅದು ಅಸ್ಪಷ್ಟತೆಯ ಹಂತವನ್ನು ತಲುಪಿದಾಗ (| ಆಲ್ಟರ್ನೇಶನ್ ಅಥವಾ *, + ಕ್ವಾಂಟಿಫೈಯರ್ ನಂತಹ), ಅದು ಒಂದು ಮಾರ್ಗವನ್ನು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಆ ಮಾರ್ಗವು ಅಂತಿಮವಾಗಿ ವಿಫಲವಾದರೆ, ಅದು ಕೊನೆಯ ನಿರ್ಧಾರದ ಹಂತಕ್ಕೆ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಮುಂದಿನ ಲಭ್ಯವಿರುವ ಮಾರ್ಗವನ್ನು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.
ಈ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಸಾಮರ್ಥ್ಯವೇ NFA ಎಂಜಿನ್‌ಗಳನ್ನು ಅಷ್ಟು ಶಕ್ತಿಯುತ ಮತ್ತು ವೈಶಿಷ್ಟ್ಯ-ಭರಿತವಾಗಿಸುತ್ತದೆ, ಲುಕ್‌ಅರೌಂಡ್‌ಗಳು ಮತ್ತು ಬ್ಯಾಕ್‌ರೆಫರೆನ್ಸ್‌ಗಳೊಂದಿಗೆ ಸಂಕೀರ್ಣ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ಅವುಗಳ ಅಕಿಲ್ಸ್ ಹೀಲ್ ಕೂಡ ಆಗಿದೆ, ಏಕೆಂದರೆ ಕ್ಯಾಟಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಕಾರ್ಯವಿಧಾನ ಇದೇ ಆಗಿದೆ.
ಈ ಮಾರ್ಗದರ್ಶಿಯ ಉಳಿದ ಭಾಗದಲ್ಲಿ, ನಮ್ಮ ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳು NFA ಎಂಜಿನ್ ಅನ್ನು ನಿಯಂತ್ರಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತವೆ, ಏಕೆಂದರೆ ಡೆವಲಪರ್‌ಗಳು ಹೆಚ್ಚಾಗಿ ಇಲ್ಲಿಯೇ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸುತ್ತಾರೆ.
NFA ಎಂಜಿನ್‌ಗಳಿಗಾಗಿ ಪ್ರಮುಖ ಆಪ್ಟಿಮೈಸೇಶನ್ ತತ್ವಗಳು
ಈಗ, ಉನ್ನತ-ಕಾರ್ಯಕ್ಷಮತೆಯ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಬರೆಯಲು ನೀವು ಬಳಸಬಹುದಾದ ಪ್ರಾಯೋಗಿಕ, ಕಾರ್ಯಸಾಧ್ಯವಾದ ತಂತ್ರಗಳಿಗೆ ಧುಮುಕೋಣ.
1. ನಿರ್ದಿಷ್ಟವಾಗಿರಿ: ನಿಖರತೆಯ ಶಕ್ತಿ
ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಆಂಟಿ-ಪ್ಯಾಟರ್ನ್ ಎಂದರೆ .* ನಂತಹ ಅತಿಯಾದ ಜೆನೆರಿಕ್ ವೈಲ್ಡ್‌ಕಾರ್ಡ್‌ಗಳನ್ನು ಬಳಸುವುದು. ಡಾಟ್ . (ಬಹುತೇಕ) ಯಾವುದೇ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ, ಮತ್ತು ಆಸ್ಟರಿಸ್ಕ್ * ಎಂದರೆ "ಶೂನ್ಯ ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ". ಇವೆರಡನ್ನು ಸಂಯೋಜಿಸಿದಾಗ, ಅವು ಎಂಜಿನ್‌ಗೆ ಸ್ಟ್ರಿಂಗ್‌ನ ಸಂಪೂರ್ಣ ಉಳಿದ ಭಾಗವನ್ನು ಗ್ರೀಡಿಯಾಗಿ ಬಳಸಿಕೊಳ್ಳಲು ಮತ್ತು ನಂತರ ಪ್ಯಾಟರ್ನ್‌ನ ಉಳಿದ ಭಾಗವು ಹೊಂದಿಕೆಯಾಗಬಹುದೇ ಎಂದು ನೋಡಲು ಒಂದೊಂದೇ ಅಕ್ಷರವನ್ನು ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಸೂಚಿಸುತ್ತವೆ. ಇದು ನಂಬಲಾಗದಷ್ಟು ಅಸಮರ್ಥವಾಗಿದೆ.
ಕೆಟ್ಟ ಉದಾಹರಣೆ (HTML ಶೀರ್ಷಿಕೆಯನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು):
<title>.*</title>
ಒಂದು ದೊಡ್ಡ HTML ಡಾಕ್ಯುಮೆಂಟ್‌ನ ವಿರುದ್ಧ, .* ಮೊದಲು ಫೈಲ್‌ನ ಅಂತ್ಯದವರೆಗೆ ಎಲ್ಲವನ್ನೂ ಹೊಂದಿಸುತ್ತದೆ. ನಂತರ, ಅದು ಅಂತಿಮ </title> ಅನ್ನು ಹುಡುಕುವವರೆಗೆ ಅಕ್ಷರದಿಂದ ಅಕ್ಷರಕ್ಕೆ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ. ಇದು ಬಹಳಷ್ಟು ಅನಗತ್ಯ ಕೆಲಸ.
ಉತ್ತಮ ಉದಾಹರಣೆ (ನಿರಾಕರಿಸಿದ ಅಕ್ಷರ ವರ್ಗವನ್ನು ಬಳಸುವುದು):
<title>[^<]*</title>
ಈ ಆವೃತ್ತಿಯು ಹೆಚ್ಚು ಸಮರ್ಥವಾಗಿದೆ. ನಿರಾಕರಿಸಿದ ಅಕ್ಷರ ವರ್ಗ [^<]* ಎಂದರೆ "'<' ಅಲ್ಲದ ಯಾವುದೇ ಅಕ್ಷರವನ್ನು ಶೂನ್ಯ ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಹೊಂದಿಸು." ಎಂಜಿನ್ ಮುಂದೆ ಸಾಗುತ್ತದೆ, ಮೊದಲ '<' ಅನ್ನು ತಲುಪುವವರೆಗೆ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ. ಅದು ಎಂದಿಗೂ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕಾಗಿಲ್ಲ. ಇದು ನೇರವಾದ, ಅಸ್ಪಷ್ಟವಲ್ಲದ ಸೂಚನೆಯಾಗಿದ್ದು, ಇದು ದೊಡ್ಡ ಕಾರ್ಯಕ್ಷಮತೆಯ ಲಾಭಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.
2. ಗ್ರೀಡಿ vs. ಲೇಜಿನೆಸ್ ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ: ಪ್ರಶ್ನಾರ್ಥಕ ಚಿಹ್ನೆಯ ಶಕ್ತಿ
ರೆಜೆಕ್ಸ್‌ನಲ್ಲಿ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಗ್ರೀಡಿಯಾಗಿರುತ್ತವೆ. ಇದರರ್ಥ ಒಟ್ಟಾರೆ ಪ್ಯಾಟರ್ನ್ ಹೊಂದಿಕೆಯಾಗಲು ಅನುವು ಮಾಡಿಕೊಡುವಾಗ ಅವು ಸಾಧ್ಯವಾದಷ್ಟು ಪಠ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತವೆ.
- ಗ್ರೀಡಿ:
*,+,?,{n,m}
ಯಾವುದೇ ಕ್ವಾಂಟಿಫೈಯರ್ ಅನ್ನು ಅದರ ನಂತರ ಪ್ರಶ್ನಾರ್ಥಕ ಚಿಹ್ನೆಯನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ನೀವು ಲೇಜಿ ಮಾಡಬಹುದು. ಲೇಜಿ ಕ್ವಾಂಟಿಫೈಯರ್ ಸಾಧ್ಯವಾದಷ್ಟು ಕಡಿಮೆ ಪಠ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.
- ಲೇಜಿ:
*?,+?,??,{n,m}?
ಉದಾಹರಣೆ: ದಪ್ಪ ಟ್ಯಾಗ್‌ಗಳನ್ನು ಹೊಂದಿಸುವುದು
ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್: <b>First</b> and <b>Second</b>
- ಗ್ರೀಡಿ ಪ್ಯಾಟರ್ನ್:
<b>.*</b>
ಇದು ಹೊಂದಿಸುತ್ತದೆ:<b>First</b> and <b>Second</b>..*ಕೊನೆಯ</b>ವರೆಗೆ ಎಲ್ಲವನ್ನೂ ಗ್ರೀಡಿಯಾಗಿ ಬಳಸಿಕೊಂಡಿದೆ. - ಲೇಜಿ ಪ್ಯಾಟರ್ನ್:
<b>.*?</b>
ಇದು ಮೊದಲ ಪ್ರಯತ್ನದಲ್ಲಿ<b>First</b>ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ, ಮತ್ತು ನೀವು ಮತ್ತೆ ಹುಡುಕಿದರೆ<b>Second</b>ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ..*?ಪ್ಯಾಟರ್ನ್‌ನ ಉಳಿದ ಭಾಗಕ್ಕೆ (</b>) ಹೊಂದಿಕೆಯಾಗಲು ಅಗತ್ಯವಿರುವ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿಸಿದೆ.
ಲೇಜಿನೆಸ್ ಕೆಲವು ಹೊಂದಾಣಿಕೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬಹುದಾದರೂ, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಒಂದು ರಾಮಬಾಣವಲ್ಲ. ಲೇಜಿ ಹೊಂದಾಣಿಕೆಯ ಪ್ರತಿಯೊಂದು ಹಂತಕ್ಕೂ ಎಂಜಿನ್ ಪ್ಯಾಟರ್ನ್‌ನ ಮುಂದಿನ ಭಾಗವು ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಅಗತ್ಯವಿದೆ. ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾದ ಪ್ಯಾಟರ್ನ್ (ಹಿಂದಿನ ಅಂಶದಿಂದ ನಿರಾಕರಿಸಿದ ಅಕ್ಷರ ವರ್ಗದಂತೆ) ಸಾಮಾನ್ಯವಾಗಿ ಲೇಜಿ ಒಂದಕ್ಕಿಂತ ವೇಗವಾಗಿರುತ್ತದೆ.
ಕಾರ್ಯಕ್ಷಮತೆಯ ಕ್ರಮ (ವೇಗದಿಂದ ನಿಧಾನಕ್ಕೆ):
- ನಿರ್ದಿಷ್ಟ/ನಿರಾಕರಿಸಿದ ಅಕ್ಷರ ವರ್ಗ:
<b>[^<]*</b> - ಲೇಜಿ ಕ್ವಾಂಟಿಫೈಯರ್:
<b>.*?</b> - ಬಹಳಷ್ಟು ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್‌ನೊಂದಿಗೆ ಗ್ರೀಡಿ ಕ್ವಾಂಟಿಫೈಯರ್:
<b>.*</b>
3. ಕ್ಯಾಟಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ತಪ್ಪಿಸಿ: ನೆಸ್ಟೆಡ್ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳನ್ನು ನಿಯಂತ್ರಿಸುವುದು
ನಾವು ಆರಂಭಿಕ ಉದಾಹರಣೆಯಲ್ಲಿ ನೋಡಿದಂತೆ, ಕ್ಯಾಟಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್‌ನ ನೇರ ಕಾರಣವೆಂದರೆ ಒಂದೇ ಪಠ್ಯವನ್ನು ಹೊಂದಿಸಬಲ್ಲ ಮತ್ತೊಂದು ಕ್ವಾಂಟಿಫೈಯರ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಕ್ವಾಂಟಿಫೈಡ್ ಗುಂಪನ್ನು ಹೊಂದಿರುವ ಪ್ಯಾಟರ್ನ್. ಎಂಜಿನ್ ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ವಿಭಜಿಸಲು ಬಹು ಮಾರ್ಗಗಳೊಂದಿಗೆ ಒಂದು ಅಸ್ಪಷ್ಟ ಪರಿಸ್ಥಿತಿಯನ್ನು ಎದುರಿಸುತ್ತದೆ.
ಸಮಸ್ಯಾತ್ಮಕ ಪ್ಯಾಟರ್ನ್‌ಗಳು:
(a+)+(a*)*(a|aa)+(a|b)*ಇಲ್ಲಿ ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಅನೇಕ 'a' ಗಳು ಮತ್ತು 'b' ಗಳಿವೆ.
ಪರಿಹಾರವೆಂದರೆ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಅಸ್ಪಷ್ಟವಲ್ಲದಂತೆ ಮಾಡುವುದು. ಕೊಟ್ಟಿರುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೊಂದಿಸಲು ಎಂಜಿನ್‌ಗೆ ಒಂದೇ ಒಂದು ಮಾರ್ಗವಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ.
4. ಅಟಾಮಿಕ್ ಗ್ರೂಪ್‌ಗಳು ಮತ್ತು ಪೊಸೆಸಿವ್ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ
ನಿಮ್ಮ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಿಂದ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ಕಡಿತಗೊಳಿಸಲು ಇದು ಅತ್ಯಂತ ಶಕ್ತಿಯುತ ತಂತ್ರಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಅಟಾಮಿಕ್ ಗ್ರೂಪ್‌ಗಳು ಮತ್ತು ಪೊಸೆಸಿವ್ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳು ಎಂಜಿನ್‌ಗೆ ಹೇಳುತ್ತವೆ: "ಒಮ್ಮೆ ನೀವು ಪ್ಯಾಟರ್ನ್‌ನ ಈ ಭಾಗವನ್ನು ಹೊಂದಿಸಿದ ನಂತರ, ಯಾವುದೇ ಅಕ್ಷರಗಳನ್ನು ಎಂದಿಗೂ ಹಿಂದಿರುಗಿಸಬೇಡಿ. ಈ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗೆ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಡಿ."
ಪೊಸೆಸಿವ್ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳು
ಸಾಮಾನ್ಯ ಕ್ವಾಂಟಿಫೈಯರ್‌ನ ನಂತರ + ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಪೊಸೆಸಿವ್ ಕ್ವಾಂಟಿಫೈಯರ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ (ಉದಾ., *+, ++, ?+, {n,m}+). ಅವು ಜಾವಾ, PCRE (PHP, R), ಮತ್ತು ರೂಬಿಯಂತಹ ಎಂಜಿನ್‌ಗಳಿಂದ ಬೆಂಬಲಿತವಾಗಿವೆ.
ಉದಾಹರಣೆ: 'a' ನಂತರ ಬರುವ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿಸುವುದು
ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್: 12345
- ಸಾಮಾನ್ಯ ರೆಜೆಕ್ಸ್:
\d+a\d+"12345" ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ನಂತರ, ಎಂಜಿನ್ 'a' ಅನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಮತ್ತು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. ಅದು ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ\d+ಈಗ "1234" ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ, ಮತ್ತು ಅದು '5' ಗೆ ವಿರುದ್ಧವಾಗಿ 'a' ಅನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.\d+ತನ್ನ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಬಿಟ್ಟುಕೊಡುವವರೆಗೆ ಇದು ಮುಂದುವರಿಯುತ್ತದೆ. ವಿಫಲಗೊಳ್ಳಲು ಇದು ಬಹಳಷ್ಟು ಕೆಲಸ. - ಪೊಸೆಸಿವ್ ರೆಜೆಕ್ಸ್:
\d++a\d++ಪೊಸೆಸಿವ್ ಆಗಿ "12345" ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ನಂತರ ಎಂಜಿನ್ 'a' ಅನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಮತ್ತು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. ಕ್ವಾಂಟಿಫೈಯರ್ ಪೊಸೆಸಿವ್ ಆಗಿದ್ದರಿಂದ, ಎಂಜಿನ್‌ಗೆ\d++ಭಾಗಕ್ಕೆ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದನ್ನು ನಿಷೇಧಿಸಲಾಗಿದೆ. ಅದು ತಕ್ಷಣವೇ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. ಇದನ್ನು 'ವೇಗವಾಗಿ ವಿಫಲವಾಗುವುದು' ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಇದು ಅತ್ಯಂತ ಸಮರ್ಥವಾಗಿದೆ.
ಅಟಾಮಿಕ್ ಗ್ರೂಪ್‌ಗಳು
ಅಟಾಮಿಕ್ ಗ್ರೂಪ್‌ಗಳು (?>...) ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಹೊಂದಿವೆ ಮತ್ತು ಪೊಸೆಸಿವ್ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳಿಗಿಂತ ಹೆಚ್ಚು ವ್ಯಾಪಕವಾಗಿ ಬೆಂಬಲಿತವಾಗಿವೆ (ಉದಾ., .NET, ಪೈಥಾನ್‌ನ ಹೊಸ `regex` ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿ). ಅವು ಪೊಸೆಸಿವ್ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳಂತೆಯೇ ವರ್ತಿಸುತ್ತವೆ ಆದರೆ ಸಂಪೂರ್ಣ ಗುಂಪಿಗೆ ಅನ್ವಯಿಸುತ್ತವೆ.
(?>\d+)a ರೆಜೆಕ್ಸ್ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ \d++a ಗೆ ಸಮಾನವಾಗಿದೆ. ಮೂಲ ಕ್ಯಾಟಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನೀವು ಅಟಾಮಿಕ್ ಗ್ರೂಪ್‌ಗಳನ್ನು ಬಳಸಬಹುದು:
ಮೂಲ ಸಮಸ್ಯೆ: (a+)+
ಅಟಾಮಿಕ್ ಪರಿಹಾರ: ((?>a+))+
ಈಗ, ಒಳಗಿನ ಗುಂಪು (?>a+) 'a' ಗಳ ಅನುಕ್ರಮವನ್ನು ಹೊಂದಿಸಿದಾಗ, ಅದು ಹೊರಗಿನ ಗುಂಪು ಪುನಃ ಪ್ರಯತ್ನಿಸಲು ಅವುಗಳನ್ನು ಎಂದಿಗೂ ಬಿಟ್ಟುಕೊಡುವುದಿಲ್ಲ. ಇದು ಅಸ್ಪಷ್ಟತೆಯನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಘಾತೀಯ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ತಡೆಯುತ್ತದೆ.
5. ಆಲ್ಟರ್ನೇಶನ್‌ಗಳ ಕ್ರಮವು ಮುಖ್ಯವಾಗುತ್ತದೆ
ಒಂದು NFA ಎಂಜಿನ್ ಆಲ್ಟರ್ನೇಶನ್ ಅನ್ನು ಎದುರಿಸಿದಾಗ (`|` ಪೈಪ್ ಬಳಸಿ), ಅದು ಪರ್ಯಾಯಗಳನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಇದರರ್ಥ ನೀವು ಮೊದಲು ಅತ್ಯಂತ ಸಂಭವನೀಯ ಪರ್ಯಾಯವನ್ನು ಇರಿಸಬೇಕು.
ಉದಾಹರಣೆ: ಒಂದು ಕಮಾಂಡ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು
ನೀವು ಕಮಾಂಡ್‌ಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತಿದ್ದೀರಿ ಎಂದು ಊಹಿಸಿ, ಮತ್ತು `GET` ಕಮಾಂಡ್ 80% ಸಮಯ, `SET` 15% ಸಮಯ, ಮತ್ತು `DELETE` 5% ಸಮಯ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ.
ಕಡಿಮೆ ಸಮರ್ಥ: ^(DELETE|SET|GET)
ನಿಮ್ಮ ಇನ್‌ಪುಟ್‌ಗಳ 80% ಮೇಲೆ, ಎಂಜಿನ್ ಮೊದಲು `DELETE` ಅನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ, ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ, `SET` ಅನ್ನು ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ, ವಿಫಲಗೊಳ್ಳುತ್ತದೆ, ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಅಂತಿಮವಾಗಿ `GET` ನೊಂದಿಗೆ ಯಶಸ್ವಿಯಾಗುತ್ತದೆ.
ಹೆಚ್ಚು ಸಮರ್ಥ: ^(GET|SET|DELETE)
ಈಗ, 80% ಸಮಯ, ಎಂಜಿನ್ ಮೊದಲ ಪ್ರಯತ್ನದಲ್ಲೇ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪಡೆಯುತ್ತದೆ. ಲಕ್ಷಾಂತರ ಸಾಲುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ ಈ ಸಣ್ಣ ಬದಲಾವಣೆಯು ಗಮನಾರ್ಹ ಪರಿಣಾಮವನ್ನು ಬೀರಬಹುದು.
6. ನಿಮಗೆ ಕ್ಯಾಪ್ಚರ್ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್‌ಗಳನ್ನು ಬಳಸಿ
ರೆಜೆಕ್ಸ್‌ನಲ್ಲಿ ಪ್ಯಾರಾಂಥಿಸಿಸ್ (...) ಎರಡು ಕೆಲಸಗಳನ್ನು ಮಾಡುತ್ತದೆ: ಅವು ಒಂದು ಉಪ-ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಗುಂಪು ಮಾಡುತ್ತವೆ, ಮತ್ತು ಅವು ಆ ಉಪ-ಪ್ಯಾಟರ್ನ್‌ಗೆ ಹೊಂದಿಕೆಯಾದ ಪಠ್ಯವನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡುತ್ತವೆ. ಈ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಪಠ್ಯವನ್ನು ನಂತರದ ಬಳಕೆಗಾಗಿ ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ (ಉದಾ., `\1` ನಂತಹ ಬ್ಯಾಕ್‌ರೆಫರೆನ್ಸ್‌ಗಳಲ್ಲಿ ಅಥವಾ ಕರೆಯುವ ಕೋಡ್‌ನಿಂದ ಹೊರತೆಗೆಯಲು). ಈ ಸಂಗ್ರಹಣೆಯು ಸಣ್ಣ ಆದರೆ ಅಳೆಯಬಹುದಾದ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಹೊಂದಿದೆ.
ನಿಮಗೆ ಕೇವಲ ಗ್ರೂಪಿಂಗ್ ವರ್ತನೆ ಬೇಕಾಗಿದ್ದರೆ ಆದರೆ ಪಠ್ಯವನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ, ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್ ಅನ್ನು ಬಳಸಿ: (?:...).
ಕ್ಯಾಪ್ಚರಿಂಗ್: (https?|ftp)://([^/]+)
ಇದು "http" ಮತ್ತು ಡೊಮೇನ್ ಹೆಸರನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಕ್ಯಾಪ್ಚರ್ ಮಾಡುತ್ತದೆ.
ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್: (?:https?|ftp)://([^/]+)
ಇಲ್ಲಿ, ನಾವು `https?|ftp` ಅನ್ನು ಇನ್ನೂ ಗುಂಪು ಮಾಡುತ್ತೇವೆ ಇದರಿಂದ `://` ಸರಿಯಾಗಿ ಅನ್ವಯಿಸುತ್ತದೆ, ಆದರೆ ನಾವು ಹೊಂದಿಕೆಯಾದ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ. ನೀವು ಕೇವಲ ಡೊಮೇನ್ ಹೆಸರನ್ನು ಹೊರತೆಗೆಯುವ ಬಗ್ಗೆ ಕಾಳಜಿ ವಹಿಸಿದರೆ ಇದು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಮರ್ಥವಾಗಿರುತ್ತದೆ (ಇದು ಗುಂಪು 1 ರಲ್ಲಿದೆ).
ಸುಧಾರಿತ ತಂತ್ರಗಳು ಮತ್ತು ಎಂಜಿನ್-ನಿರ್ದಿಷ್ಟ ಸಲಹೆಗಳು
ಲುಕ್‌ಅರೌಂಡ್‌ಗಳು: ಶಕ್ತಿಯುತ ಆದರೆ ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸಿ
ಲುಕ್‌ಅರೌಂಡ್‌ಗಳು (ಲುಕ್‌ಅಹೆಡ್ (?=...), (?!...) ಮತ್ತು ಲುಕ್‌ಬೆಹೈಂಡ್ (?<=...), (?) ಶೂನ್ಯ-ಅಗಲದ ಪ್ರತಿಪಾದನೆಗಳಾಗಿವೆ. ಅವು ಯಾವುದೇ ಅಕ್ಷರಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳದೆ ಒಂದು ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತವೆ. ಸಂದರ್ಭವನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಇದು ತುಂಬಾ ಸಮರ್ಥವಾಗಿರುತ್ತದೆ.
ಉದಾಹರಣೆ: ಪಾಸ್‌ವರ್ಡ್ ಮೌಲ್ಯೀಕರಣ
ಒಂದು ಅಂಕಿಯನ್ನು ಹೊಂದಿರಬೇಕಾದ ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಒಂದು ರೆಜೆಕ್ಸ್:
^(?=.*\d).{8,}$
ಇದು ತುಂಬಾ ಸಮರ್ಥವಾಗಿದೆ. ಲುಕ್‌ಅಹೆಡ್ (?=.*\d) ಒಂದು ಅಂಕಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮುಂದೆ ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ, ಮತ್ತು ನಂತರ ಕರ್ಸರ್ ಆರಂಭಕ್ಕೆ ಮರುಹೊಂದಿಸುತ್ತದೆ. ಪ್ಯಾಟರ್ನ್‌ನ ಮುಖ್ಯ ಭಾಗ, .{8,}, ನಂತರ ಕೇವಲ 8 ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿಸಬೇಕಾಗುತ್ತದೆ. ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಸಂಕೀರ್ಣ, ಏಕ-ಮಾರ್ಗದ ಪ್ಯಾಟರ್ನ್‌ಗಿಂತ ಉತ್ತಮವಾಗಿರುತ್ತದೆ.
ಪೂರ್ವ-ಗಣನೆ ಮತ್ತು ಕಂಪೈಲೇಶನ್
ಹೆಚ್ಚಿನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಒಂದು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಅನ್ನು "ಕಂಪೈಲ್" ಮಾಡಲು ಒಂದು ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ. ಇದರರ್ಥ ಎಂಜಿನ್ ಪ್ಯಾಟರ್ನ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಒಮ್ಮೆ ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಒಂದು ಆಪ್ಟಿಮೈಸ್ಡ್ ಆಂತರಿಕ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ರಚಿಸುತ್ತದೆ. ನೀವು ಒಂದೇ ರೆಜೆಕ್ಸ್ ಅನ್ನು ಅನೇಕ ಬಾರಿ ಬಳಸುತ್ತಿದ್ದರೆ (ಉದಾ., ಒಂದು ಲೂಪ್‌ನೊಳಗೆ), ನೀವು ಅದನ್ನು ಯಾವಾಗಲೂ ಲೂಪ್‌ನ ಹೊರಗೆ ಒಮ್ಮೆ ಕಂಪೈಲ್ ಮಾಡಬೇಕು.
ಪೈಥಾನ್ ಉದಾಹರಣೆ:
import re
# ರೆಜೆಕ್ಸ್ ಅನ್ನು ಒಮ್ಮೆ ಕಂಪೈಲ್ ಮಾಡಿ
log_pattern = re.compile(r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})')
for line in log_file:
# ಕಂಪೈಲ್ ಮಾಡಿದ ಆಬ್ಜೆಕ್ಟ್ ಬಳಸಿ
match = log_pattern.search(line)
if match:
print(match.group(1))
ಇದನ್ನು ಮಾಡಲು ವಿಫಲವಾದರೆ ಎಂಜಿನ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆಯಲ್ಲೂ ಸ್ಟ್ರಿಂಗ್ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಮರು-ಪಾರ್ಸ್ ಮಾಡಲು ಒತ್ತಾಯಿಸುತ್ತದೆ, ಇದು CPU ಸೈಕಲ್‌ಗಳ ಗಮನಾರ್ಹ ವ್ಯರ್ಥ.
ರೆಜೆಕ್ಸ್ ಪ್ರೊಫೈಲಿಂಗ್ ಮತ್ತು ಡೀಬಗ್ಗಿಂಗ್‌ಗಾಗಿ ಪ್ರಾಯೋಗಿಕ ಪರಿಕರಗಳು
ಸಿದ್ಧಾಂತವು ಶ್ರೇಷ್ಠ, ಆದರೆ ನೋಡುವುದೇ ನಂಬುವುದು. ಆಧುನಿಕ ಆನ್‌ಲೈನ್ ರೆಜೆಕ್ಸ್ ಪರೀಕ್ಷಕರು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಅಮೂಲ್ಯವಾದ ಪರಿಕರಗಳಾಗಿವೆ.
regex101.com ನಂತಹ ವೆಬ್‌ಸೈಟ್‌ಗಳು "ರೆಜೆಕ್ಸ್ ಡೀಬಗ್ಗರ್" ಅಥವಾ "ಹಂತ ವಿವರಣೆ" ವೈಶಿಷ್ಟ್ಯವನ್ನು ಒದಗಿಸುತ್ತವೆ. ನೀವು ನಿಮ್ಮ ರೆಜೆಕ್ಸ್ ಮತ್ತು ಒಂದು ಪರೀಕ್ಷಾ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಅಂಟಿಸಬಹುದು, ಮತ್ತು NFA ಎಂಜಿನ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಎಂಬುದರ ಹಂತ-ಹಂತದ ಜಾಡನ್ನು ಅದು ನಿಮಗೆ ನೀಡುತ್ತದೆ. ಇದು ಪ್ರತಿಯೊಂದು ಹೊಂದಾಣಿಕೆ ಪ್ರಯತ್ನ, ವೈಫಲ್ಯ, ಮತ್ತು ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ತೋರಿಸುತ್ತದೆ. ನಿಮ್ಮ ರೆಜೆಕ್ಸ್ ಏಕೆ ನಿಧಾನವಾಗಿದೆ ಎಂಬುದನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ಮತ್ತು ನಾವು ಚರ್ಚಿಸಿದ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳ ಪರಿಣಾಮವನ್ನು ಪರೀಕ್ಷಿಸಲು ಇದು ಏಕೈಕ ಅತ್ಯುತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ.
ರೆಜೆಕ್ಸ್ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಾಗಿ ಒಂದು ಪ್ರಾಯೋಗಿಕ ಪರಿಶೀಲನಾಪಟ್ಟಿ
ಒಂದು ಸಂಕೀರ್ಣ ರೆಜೆಕ್ಸ್ ಅನ್ನು ನಿಯೋಜಿಸುವ ಮೊದಲು, ಅದನ್ನು ಈ ಮಾನಸಿಕ ಪರಿಶೀಲನಾಪಟ್ಟಿಯ ಮೂಲಕ ಚಲಾಯಿಸಿ:
- ನಿರ್ದಿಷ್ಟತೆ: ನಾನು ಒಂದು ಲೇಜಿ
.*?ಅಥವಾ ಗ್ರೀಡಿ.*ಅನ್ನು ಬಳಸಿದ್ದೇನೆಯೇ, ಅಲ್ಲಿ[^"\r\n]*ನಂತಹ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾದ ನಿರಾಕರಿಸಿದ ಅಕ್ಷರ ವರ್ಗವು ವೇಗವಾಗಿ ಮತ್ತು ಸುರಕ್ಷಿತವಾಗಿರುತ್ತದೆಯೇ? - ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್: ನನ್ನಲ್ಲಿ
(a+)+ನಂತಹ ನೆಸ್ಟೆಡ್ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳಿವೆಯೇ? ಕೆಲವು ಇನ್‌ಪುಟ್‌ಗಳಲ್ಲಿ ಕ್ಯಾಟಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್‌ಗೆ ಕಾರಣವಾಗಬಹುದಾದ ಅಸ್ಪಷ್ಟತೆ ಇದೆಯೇ? - ಪೊಸೆಸಿವ್‌ನೆಸ್: ಮರು-ಮೌಲ್ಯಮಾಪನ ಮಾಡಬಾರದೆಂದು ನನಗೆ ತಿಳಿದಿರುವ ಒಂದು ಉಪ-ಪ್ಯಾಟರ್ನ್‌ಗೆ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ತಡೆಯಲು ನಾನು ಅಟಾಮಿಕ್ ಗ್ರೂಪ್
(?>...)ಅಥವಾ ಪೊಸೆಸಿವ್ ಕ್ವಾಂಟಿಫೈಯರ್*+ಅನ್ನು ಬಳಸಬಹುದೇ? - ಆಲ್ಟರ್ನೇಶನ್‌ಗಳು: ನನ್ನ
(a|b|c)ಆಲ್ಟರ್ನೇಶನ್‌ಗಳಲ್ಲಿ, ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾದ ಪರ್ಯಾಯವನ್ನು ಮೊದಲು ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆಯೇ? - ಕ್ಯಾಪ್ಚರಿಂಗ್: ನನ್ನ ಎಲ್ಲಾ ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗುಂಪುಗಳು ನನಗೆ ಬೇಕೇ? ಓವರ್‌ಹೆಡ್ ಕಡಿಮೆ ಮಾಡಲು ಕೆಲವನ್ನು ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗುಂಪುಗಳಾಗಿ
(?:...)ಪರಿವರ್ತಿಸಬಹುದೇ? - ಕಂಪೈಲೇಶನ್: ನಾನು ಈ ರೆಜೆಕ್ಸ್ ಅನ್ನು ಒಂದು ಲೂಪ್‌ನಲ್ಲಿ ಬಳಸುತ್ತಿದ್ದರೆ, ನಾನು ಅದನ್ನು ಪೂರ್ವ-ಕಂಪೈಲ್ ಮಾಡುತ್ತಿದ್ದೇನೆಯೇ?
ಕೇಸ್ ಸ್ಟಡಿ: ಒಂದು ಲಾಗ್ ಪಾರ್ಸರ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು
ಎಲ್ಲವನ್ನೂ ಒಟ್ಟಿಗೆ ಸೇರಿಸೋಣ. ನಾವು ಒಂದು ಪ್ರಮಾಣಿತ ವೆಬ್ ಸರ್ವರ್ ಲಾಗ್ ಲೈನ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತಿದ್ದೇವೆ ಎಂದು ಊಹಿಸಿ.
ಲಾಗ್ ಲೈನ್: 127.0.0.1 - - [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326
ಮೊದಲು (ನಿಧಾನ ರೆಜೆಕ್ಸ್):
^(\S+) (\S+) (\S+) \[(.*)\] "(.*)" (\d+) (\d+)$
ಈ ಪ್ಯಾಟರ್ನ್ ಕ್ರಿಯಾತ್ಮಕವಾಗಿದೆ ಆದರೆ ಅಸಮರ್ಥವಾಗಿದೆ. ದಿನಾಂಕ ಮತ್ತು ವಿನಂತಿ ಸ್ಟ್ರಿಂಗ್‌ಗಾಗಿ (.*) ಗಮನಾರ್ಹವಾಗಿ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ದೋಷಪೂರಿತ ಲಾಗ್ ಲೈನ್‌ಗಳಿದ್ದರೆ.
ನಂತರ (ಆಪ್ಟಿಮೈಸ್ಡ್ ರೆಜೆಕ್ಸ್):
^(\S+) (\S+) (\S+) \[[^\]]+\] "(?:GET|POST|HEAD) ([^ "]+) HTTP/[\d.]+" (\d{3}) (\d+)$
ಸುಧಾರಣೆಗಳನ್ನು ವಿವರಿಸಲಾಗಿದೆ:
\[(.*)\]\[[^\]]+\]ಆಯಿತು. ನಾವು ಜೆನೆರಿಕ್, ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್.*ಅನ್ನು ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾದ ನಿರಾಕರಿಸಿದ ಅಕ್ಷರ ವರ್ಗದೊಂದಿಗೆ ಬದಲಾಯಿಸಿದ್ದೇವೆ, ಅದು ಮುಚ್ಚುವ ಬ್ರಾಕೆಟ್ ಹೊರತುಪಡಿಸಿ ಯಾವುದನ್ನಾದರೂ ಹೊಂದಿಸುತ್ತದೆ. ಯಾವುದೇ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಅಗತ್ಯವಿಲ್ಲ."(.*)""(?:GET|POST|HEAD) ([^ "]+) HTTP/[\d.]+"ಆಯಿತು. ಇದು ಒಂದು ಬೃಹತ್ ಸುಧಾರಣೆಯಾಗಿದೆ.- ನಾವು ನಿರೀಕ್ಷಿಸುವ HTTP ವಿಧಾನಗಳ ಬಗ್ಗೆ ನಾವು ಸ್ಪಷ್ಟವಾಗಿದ್ದೇವೆ, ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗುಂಪನ್ನು ಬಳಸುತ್ತೇವೆ.
- ನಾವು ಜೆನೆರಿಕ್ ವೈಲ್ಡ್‌ಕಾರ್ಡ್ ಬದಲಿಗೆ
[^ "]+(ಒಂದು ಸ್ಪೇಸ್ ಅಥವಾ ಉದ್ಧರಣ ಚಿಹ್ನೆ ಅಲ್ಲದ ಒಂದು ಅಥವಾ ಹೆಚ್ಚು ಅಕ್ಷರಗಳು) ನೊಂದಿಗೆ URL ಪಥವನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ. - ನಾವು HTTP ಪ್ರೋಟೋಕಾಲ್ ಫಾರ್ಮ್ಯಾಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ.
- ಸ್ಥಿತಿ ಕೋಡ್‌ಗಾಗಿ
(\d+)ಅನ್ನು(\d{3})ಗೆ ಬಿಗಿಗೊಳಿಸಲಾಗಿದೆ, ಏಕೆಂದರೆ HTTP ಸ್ಥಿತಿ ಕೋಡ್‌ಗಳು ಯಾವಾಗಲೂ ಮೂರು ಅಂಕಿಗಳಾಗಿರುತ್ತವೆ.
'ನಂತರ'ದ ಆವೃತ್ತಿಯು ನಾಟಕೀಯವಾಗಿ ವೇಗವಾಗಿ ಮತ್ತು ReDoS ದಾಳಿಯಿಂದ ಸುರಕ್ಷಿತವಾಗಿರುವುದು ಮಾತ್ರವಲ್ಲದೆ, ಇದು ಹೆಚ್ಚು ದೃಢವಾಗಿರುತ್ತದೆ ಏಕೆಂದರೆ ಇದು ಲಾಗ್ ಲೈನ್‌ನ ಸ್ವರೂಪವನ್ನು ಹೆಚ್ಚು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ.
ತೀರ್ಮಾನ
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಎರಡು ಅಲುಗಿನ ಕತ್ತಿ. ಕಾಳಜಿ ಮತ್ತು ಜ್ಞಾನದಿಂದ ಬಳಸಿದರೆ, ಅವು ಸಂಕೀರ್ಣ ಪಠ್ಯ ಸಂಸ್ಕರಣೆಯ ಸಮಸ್ಯೆಗಳಿಗೆ ಒಂದು ಸೊಗಸಾದ ಪರಿಹಾರ. ಅಸಡ್ಡೆಯಿಂದ ಬಳಸಿದರೆ, ಅವು ಕಾರ್ಯಕ್ಷಮತೆಯ ದುಃಸ್ವಪ್ನವಾಗಬಹುದು. ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ NFA ಎಂಜಿನ್‌ನ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಕಾರ್ಯವಿಧಾನದ ಬಗ್ಗೆ ಗಮನವಿಡುವುದು ಮತ್ತು ಸಾಧ್ಯವಾದಷ್ಟು ಹೆಚ್ಚಾಗಿ ಎಂಜಿನ್ ಅನ್ನು ಒಂದೇ, ಅಸ್ಪಷ್ಟವಲ್ಲದ ಮಾರ್ಗದಲ್ಲಿ ಮಾರ್ಗದರ್ಶಿಸುವ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಬರೆಯುವುದು.
ನಿರ್ದಿಷ್ಟವಾಗಿರುವ ಮೂಲಕ, ಗ್ರೀಡಿನೆಸ್ ಮತ್ತು ಲೇಜಿನೆಸ್‌ನ ವಹಿವಾಟುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ಅಟಾಮಿಕ್ ಗ್ರೂಪ್‌ಗಳೊಂದಿಗೆ ಅಸ್ಪಷ್ಟತೆಯನ್ನು ನಿವಾರಿಸುವ ಮೂಲಕ, ಮತ್ತು ನಿಮ್ಮ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಸರಿಯಾದ ಪರಿಕರಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ನೀವು ನಿಮ್ಮ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಸಂಭಾವ್ಯ ಹೊಣೆಗಾರಿಕೆಯಿಂದ ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ಶಕ್ತಿಯುತ ಮತ್ತು ಸಮರ್ಥ ಆಸ್ತಿಯಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು. ಇಂದೇ ನಿಮ್ಮ ರೆಜೆಕ್ಸ್ ಅನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ವೇಗವಾದ, ಹೆಚ್ಚು ವಿಶ್ವಾಸಾರ್ಹ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿ.